/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "物理.h"

using namespace std;


#include <ppl.h>


#include <S_键值序列容器.h>


#include "物体/实现包含物体.h"
#include <面/面.h>
#include <物体/物体.h>

#include "intern/后端/FLIP/FLIP对外接口.h"
#include "intern/后端/PBF/S_PhysicsPBD.h"

#include "intern/后端/PhysX/C_物体管理/S_PhysicsPhysX.h"
#include "intern/后端/PhysX/B_组合物体/S_Px刚体.h"
#include "intern/后端/PhysX/B_组合物体/Px碰撞几何体.h"
#include "intern/后端/PhysX/B_组合物体/S_Px车.h"

#include "intern/后端/PhysX/A_核心/Px物体形状创建.h"
#include "intern/后端/PhysX/A_核心/Px物体形状创建.h"

//#include "intern/后端/FleX/C_实例管理/S_PhysicsFleX.h"
#include "intern/后端/PhysX/C_物体管理/S_PhysicsPhysX.h"
#include "intern/后端/ODE/C_物体管理/S_PhysicsODE.h"

#include "intern/后端/Chrono/Chrono对外接口.h"
#include "intern/后端/Bullet/Bullet对外接口.h"
#include "intern/后端/NewTon/C_物体管理/S_PhysicsNewTon.h"
#include "intern/后端/Mujoco/phy_Mujoco.h"





static S_键值序列容器<uint32, S_物理解算器*> g_物理解算器容器;




S_物理解算器* f_创建物理解算器(uint32 id) {
	g_物理解算器容器[id] = new S_物理解算器();
	return g_物理解算器容器[id];
}

S_Physics* f_phy_创建创建解算器(E_物理引擎 type, vec3 域大小) {
	S_Physics* phy = 0;
	switch (type) {
	case E_物理引擎::E_物理引擎_Mujoco: {
		phy = f_PhysMujoco_创建物理引擎();
		break;
	}
	case E_物理引擎::E_物理引擎_Bullet:
		phy = f_创建Bullet物理引擎();
		break;
	case E_物理引擎::E_物理引擎_PBF:
		phy = f_PhysPBF_创建物理引擎();
		break;
	case E_物理引擎::E_物理引擎_FLIP:
		phy = f_创建FLIP物理引擎(域大小);
		break;
	}

	phy->m_IdType = type;
	return phy;
}

void f_销毁物理解算器(uint32 id) {
	if (g_物理解算器容器.f_Key存在(id)) {
		g_物理解算器容器.f_remove(id);
	}

}

void f_phy_销毁物理解算器(S_Physics* phy) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco:
		f_PhysMujoco_销毁物理引擎(phy);
		break;
	case E_物理引擎::E_物理引擎_PBF:
		f_PhysPBF_销毁物理引擎(phy);
		break;
	case E_物理引擎::E_物理引擎_FLIP:
		f_销毁FLIP物理引擎(phy);
		break;
	}
	
}

void f_phy_重置(S_Physics* phy, const std::string& path) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco: {
		f_PhysMujoco_重置引擎(phy, path);
		break;
	}
	case E_物理引擎::E_物理引擎_Bullet:
		break;
	case E_物理引擎::E_物理引擎_PBF:
		break;
	case E_物理引擎::E_物理引擎_FLIP:
		break;
	}
}

void f_phy_重置(S_Physics* phy) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco: {
		f_PhyMujoco_重置(static_cast<S_PhysicsMujoco*>(phy));
		break;
	}
	case E_物理引擎::E_物理引擎_Bullet:
		break;
	case E_物理引擎::E_物理引擎_PBF:
		break;
	case E_物理引擎::E_物理引擎_FLIP:
		break;
	}
}

void f_phy_步进解算(S_Physics* phy) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco: {
		f_PhyMujoco_解算(static_cast<S_PhysicsMujoco*>(phy));
		break;
	}
	case E_物理引擎::E_物理引擎_Bullet:
		break;
	case E_物理引擎::E_物理引擎_PBF:
		break;
	case E_物理引擎::E_物理引擎_FLIP:
		break;
	}
}

uint32 f_phy_get解算器域分辨率(S_Physics* phy) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_FLIP:

		break;
	}
	return uint32();
}

uint32 f_物理解算器名词是否存在(uint32 key){
	return g_物理解算器容器.f_GenName(key);
}

void f_Phy_构建静态网格碰撞划分(S_Physics* phy, float32 最小单元大小) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF:
		f_PhysPBF_构建静态碰撞空间划分(phy, 最小单元大小);
		break;
	case E_物理引擎::E_物理引擎_FLIP:
		//f_销毁FLIP物理引擎(phy);
		break;
	}
}




S_物理材质* f_创建材质(S_物理解算器* 解算器, float32 静摩擦, float32 动摩擦, float32 恢复系数, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_NewTon:
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		//return new S_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		return f_PhysX物理材质(解算器->m_PhysX, 静摩擦, 动摩擦, 恢复系数);
		break;
	default:
		break;
	}

	return 0;
}














S_物理几何体* f_创建平面几何体(S_物理解算器* 解算器, const vec4& v, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_ODE:
		return f_ODE平面几何体(解算器->m_ODE, v);
		break;
	case E_物理引擎_NewTon:
		break;
	case E_物理引擎_Bullet:
		return f_Bullet平面几何体(v);
		break;
	case E_物理引擎_Chrono:
		//return new S_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		return f_PhysX平面几何体(解算器->m_PhysX, v);
		break;
	default:
		break;
	}
	
	return 0;
}

S_物理几何体* f_创建方体几何体(S_物理解算器* 解算器, const vec3& v, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_FleX:
		//return f_FleX长方体几何体(v);
		break;
	case E_物理引擎_PhysX:
		return f_PhysX长方体几何体(解算器->m_PhysX, v);
		break;
	case E_物理引擎_ODE:
		return f_ODE长方体几何体(解算器->m_ODE, v);
		break;
	case E_物理引擎_NewTon:
		if(解算器->m_NewTon) return f_NewTon长方体几何体(解算器->m_NewTon, v);
		break;
	case E_物理引擎_Bullet:
		return f_Bullet长方体几何体(v);
		break;
	case E_物理引擎_Chrono:
		return f_Chrono长方体几何体(v);
		break;
	
	default:
		break;
	}
	return 0;
}

S_物理几何体* f_创建球体几何体(S_物理解算器* 解算器, const float32 v, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		break;
	case E_物理引擎_ODE:
		break;
	case E_物理引擎_NewTon:
		break;
	case E_物理引擎_Bullet:
		return f_Bullet球体几何体(v);
		break;
	case E_物理引擎_Chrono:
		break;

	default:
		break;
	}
	return 0;
}

S_物理几何体* f_创建凸壳物理包围几何(S_物理解算器* 解算器, const S_三角Mesh mesh, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_ODE:
		return f_ODE凸壳几何体(解算器->m_ODE, mesh);
		break;
	case E_物理引擎_NewTon:
		if (解算器->m_NewTon) return f_NewTon凸壳几何体(解算器->m_NewTon, mesh);
		break;
	case E_物理引擎_Bullet:
		return f_Bullet凸壳几何体(mesh);
		break;
	case E_物理引擎_Chrono:
		return f_Chrono凸壳几何体(mesh);
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		return f_PhysX凸壳几何体(解算器->m_PhysX, mesh);
		break;
	default:
		break;
	}
	return 0;
}

S_物理几何体* f_创建网格物理几何体(S_物理解算器* 解算器, const S_三角Mesh mesh, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_ODE:
		return f_ODE凸壳几何体(解算器->m_ODE, mesh);
		break;
	case E_物理引擎_NewTon:

		break;
	case E_物理引擎_Bullet:
		return f_Bullet网格几何体(mesh);
		break;
	case E_物理引擎_Chrono:
		//return new S_Chrono凸壳几何体(mesh);
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		return f_PhysX凸壳几何体(解算器->m_PhysX, mesh);
		break;
	}
	return 0;
}

S_物理几何体* f_创建静态网格物理包围几何(S_物理解算器* 解算器, const S_三角Mesh mesh, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_ODE:
		break;
	case E_物理引擎_NewTon:

		break;
	case E_物理引擎_Bullet:
		//return new S_Bullet长方体几何体(v);
		break;
	case E_物理引擎_Chrono:
		//return new S_Chrono凸壳几何体(mesh);
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		return f_PhysX网格几何体(解算器->m_PhysX, mesh);
		break;
	}
	return 0;

}

void f_Phy_创建物理几何体(E_物理引擎 物理引擎, S_物理几何体* 几何体) {
	if (几何体->m_物理引擎枚举 != 物理引擎) {
		switch (几何体->m_物理引擎枚举) {
		case E_物理引擎_ODE:
			break;
		case E_物理引擎_NewTon:

			break;
		case E_物理引擎::E_物理引擎_Mujoco:

			break;
		case E_物理引擎_Bullet:
			//return new S_Bullet长方体几何体(v);
			break;
		case E_物理引擎_Chrono:
			//return new S_Chrono凸壳几何体(mesh);
			break;
		case E_物理引擎_FleX:
			break;
		case E_物理引擎_PhysX:
			break;
		}
	}

	switch (物理引擎) {
	case E_物理引擎_ODE:
		break;
	case E_物理引擎_NewTon:

		break;
	case E_物理引擎_Bullet:
		//return new S_Bullet长方体几何体(v);
		break;
	case E_物理引擎_Chrono:
		//return new S_Chrono凸壳几何体(mesh);
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		break;
	}
	return;
}

std::vector<S_物理体*> f_phy_get物理体(S_Physics* phy, E_物理碰撞几何类型 几何类型) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco:
		return f_PhyMujoco_get几何图形(static_cast<S_PhysicsMujoco*>(phy), 几何类型);
	
	case E_物理引擎::E_物理引擎_Bullet:
		//return new S_Bullet长方体几何体(v);
		break;

	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		break;
	}
	return {};
}

void f_Phy_内部网格填充绑定物体(S_Physics* phy, std::vector<S_物理体*>& Body) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco:
		return f_PhyMujoco_构建内部几何体填充到物体(static_cast<S_PhysicsMujoco*>(phy), Body);

	case E_物理引擎::E_物理引擎_Bullet:
		//return new S_Bullet长方体几何体(v);
		break;

	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		break;
	}
}

uint32 f_phy_get肌腱数量(S_Physics* phy) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco:
		return f_PhyMujoco_get肌腱数量(static_cast<S_PhysicsMujoco*>(phy));

	case E_物理引擎::E_物理引擎_Bullet:
		break;

	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		break;
	}
	return 0;
}

void f_phy_构建肌腱物体可视(S_Physics* phy, S_物体* Body) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco:
		f_PhyMujoco_构建肌腱物体可视(static_cast<S_PhysicsMujoco*>(phy), Body);
		return;
	case E_物理引擎::E_物理引擎_Bullet:
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		break;
	}
}

void f_phy_set肌腱力度(S_Physics* phy, float32* 力度, int32 id) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco:
		f_PhyMujoco_set肌腱力度(static_cast<S_PhysicsMujoco*>(phy), 力度, id);
		return;
	case E_物理引擎::E_物理引擎_Bullet:
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		break;
	}
}

void f_Phy_销毁内部物理几何体(S_物理几何体* geon) {

}















S_物理体* f_创建物理平面(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_Bullet:
		//return new S_Bullet静态碰撞(geom, mat);
		break;
	case E_物理引擎_Chrono:
		//return new S_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		return f_PhysX静态(解算器->m_PhysX, geom, mat);
		break;
	default:
		break;
	}

	return 0;
		
}

S_物理体* f_创建静态碰撞(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_Tranform& t) {
	switch (geom.m_物理引擎枚举) {
	case E_物理引擎_ODE:
		return f_ODE静态(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		if (解算器->m_NewTon) return f_NewTon静态(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		return f_Bullet静态(geom, mat);
		break;
	case E_物理引擎_Chrono:
		return f_Chrono静态(geom, mat);
		break;
	case E_物理引擎_FleX:
		//return f_FleX静态(geom, mat, t);
		break;
	case E_物理引擎_PhysX:
		return f_PhysX静态(解算器->m_PhysX, geom, mat);
		break;
	default:
		break;
	}

	return 0;
}

S_物理体* f_创建刚体(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_Tranform& t, float32 重量) {
	//uint32 key = obj.m_ID;
	//if (S_物理体::f_get(key) == nullptr) {
	switch (geom.m_物理引擎枚举) {
	case E_物理引擎_ODE:
		return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		return f_Bullet刚体(geom, &mat);
		break;
	case E_物理引擎_Chrono:
		return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		//return f_FleX刚体(geom, mat, t, 重量);
		break;
	case E_物理引擎_PhysX:
		return f_PhysX刚体(解算器->m_PhysX, geom, mat);
		break;
	default:
		break;
	}
	
	return 0;
}



S_物理体* f_创建控制物理体(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_Tranform& t) {
	switch (geom.m_物理引擎枚举) {
	case E_物理引擎_ODE:
		//return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		return f_Bullet控制(geom, mat);
		break;
	case E_物理引擎_Chrono:
		//return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		//return f_FleX刚体(geom, mat, t, 重量);
		break;
	case E_物理引擎_PhysX:
		return f_PhysX控制Body(解算器->m_PhysX, geom, mat);
		break;
	default:
		break;
	}
	return 0;
}

S_物理体* f_创建物理边界(S_物理解算器* 解算器, vec3 size, const S_Tranform& t, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			return 0;
		case E_物理引擎_ODE:
			//return f_ODE刚体(解算器->m_ODE, geom, mat);
			break;
		case E_物理引擎_NewTon:
			//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
			break;
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_Chrono:
			//return f_Chrono刚体(geom, mat);
			break;
		case E_物理引擎_FleX:
			//return f_FleX刚体(geom, mat, t, 重量);
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}
	return nullptr;
}

S_物理体* f_Phy_create刚体(S_Physics* phy, S_物理材质* 材质) {
	switch (phy->m_IdType) {
	
	case E_物理引擎::E_物理引擎_PBF: {
		return f_PhysPBF_创建刚体(材质);
	} break;


	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
	return nullptr;
}

S_物理体* f_Phy_create刚体(S_Physics* phy, S_物理几何体& geom, S_物理材质* 材质) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_Bullet: {
			return f_Bullet刚体(geom, 材质);
		}

		case E_物理引擎::E_物理引擎_FLIP: {
			break;
		} 
	}
	return nullptr;
}

S_物理体* f_Phy_create物理体(S_物理几何体& geom, S_物理材质* 材质, E_物理引擎 phy_type) {
	switch (phy_type) {
	case E_物理引擎::E_物理引擎_Bullet: {
		return f_Bullet刚体(geom, 材质);
	} break;


	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
	return nullptr;
}

S_物理体* f_Phy_create粒子发射(S_Physics* phy, uint32 粒子数, S_物理材质* 材质) {
	S_物理体* body = nullptr;
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		body = f_PhysPBF_创建粒子发射(粒子数, 材质);
	} break;
	case E_物理引擎::E_物理引擎_FLIP: {
	} break;
	}

	if(body) body->m_物理引擎枚举 = phy->m_IdType;
	return body;
}

/*S_PBF粒子发射* f_Phy_create粒子发射(S_Physics* phy, S_物理体* body) {
	S_PBF粒子发射* e = (S_PBF粒子发射*)malloc(sizeof(S_PBF粒子发射));
	e->m_Body = body;
	e->m_偏移 = 0;
	e->m_数量 = 0;
	e->m_位置坐标 = nullptr;
	e->m_发射方向 = nullptr;

	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PhysPBF_创建粒子发射(
	} break;
	case E_物理引擎::E_物理引擎_FLIP: {
	} break;
	}
	return e;
}*/

S_物理体* f_创建物理车轮(S_物理解算器* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_车轮参数& 属性) {
	switch (geom.m_物理引擎枚举) {
	case E_物理引擎_ODE:
		//return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		return f_Bullet刚体(geom, &mat);
		break;
	case E_物理引擎_Chrono:
		//return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		//return f_FleX刚体(geom, mat, t, 重量);
		break;
	case E_物理引擎_PhysX:
		return f_PhysX创建车轮(解算器->m_PhysX, 属性, geom, mat);
		break;
	default:
		break;
	}

	return 0;
}

S_物理体* f_创建物理车辆(S_物理解算器* 解算器, S_车体参数& 车体参数) {
	//auto& Core = dynamic_cast<S_PhysX*>(解算器->m_PhysX)->m_Core;
	S_物理体* body = 0;
	
	switch (车体参数.m_车体刚体->m_物理引擎枚举) {
	case E_物理引擎_ODE:
		//return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		return f_Bullet创建车(解算器->m_Bullet, 车体参数);
		break;
	case E_物理引擎_Chrono:
		//return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		//return f_FleX刚体(geom, mat, t, 重量);
		break;
	case E_物理引擎_PhysX:
		return f_PhysX创建车(解算器->m_PhysX, 车体参数);
		break;
	default:
		break;
	}

	return body;

	/*车->f_add构建车体(geom, mat, 车轮s);
	uint32 车轮Num = 车轮s.size();
	auto* p_车轮 = 车轮s.data();
	for (uint32 i = 0; i < 车轮Num; ++i) {
		车->f_add构建车轮(p_车轮[i]);
	}*/
	

	/*vector<S_物理几何体*> 车轮Mesh;
	for (auto& e : 车轮s) 车轮Mesh.push_back(e.m_车轮物理体);
	车->f_test(&Core, dynamic_cast<S_PhysX*>(解算器->m_PhysX)->m_Px场景s[0], 车体参数, 车轮s);*/

	
	
	return body;
}

void f_Phy_创建流体(S_Physics* phy, S_物理体* body) {

}

void f_Phy_销毁物理体(S_物理体* body) {
	switch (body->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_Bullet: {
		delete body;
		break;
	}
	case E_物理引擎::E_物理引擎_PBF: {
		delete body->m_Data; 
		break;
		//return f_PhyPBF_销毁物理体(body);
	} break;


	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
}

//using namespace physx;
void f_车辆物理体绑定物体(S_物理解算器* 解算器, S_物理体* 车, vector<void*>& 车体) {
	//return;
	/*auto* 车辆 = dynamic_cast<S_Px车*>(车);
	if (车辆) {
		auto& Core = dynamic_cast<S_PhysX*>(解算器->m_PhysX)->m_Core;
		bool 成功 = 车辆->f_test(&Core, dynamic_cast<S_PhysX*>(解算器->m_PhysX)->m_Px场景s[0], 车辆->m_车体参数, 车辆->m_车轮参数);
		if (!成功) return;

		auto& vehicle = *车辆->mVehicleManager.getVehicle(0);

		PxShape* carShapes[PX_MAX_NB_WHEELS + 1];
		const PxU32 nbShapes = vehicle.getRigidDynamicActor()->getNbShapes();
		const PxRigidDynamic& vehicleActor = *vehicle.getRigidDynamicActor();
		vehicleActor.getShapes(carShapes, nbShapes);

		for (uint32 i = 0; i < nbShapes; ++i) {
			carShapes[i]->userData = 车体[i];
		}


		const physx::PxU32 nbShapes = 车辆->m_车体刚体->getNbShapes();
		physx::PxShape* 子物体[64];
		车辆->m_车体刚体->getShapes(子物体, nbShapes);
		for (uint32 i = 0; i < nbShapes; ++i) {
			子物体[i]->userData = 车体[i];
		}
		//车辆->m_车体刚体->userData = 车体[4];
		//车辆->m_车体形状[0]->userData = 车体[4];
	}*/
}

/*void f_车辆物理体绑定物体(S_物理体* 车, vector<void*>& 车体, vector<void*>& 车轮) {
	auto* 车辆 = dynamic_cast<S_Px车*>(车);
	if (车辆) {
		const physx::PxU32 nbShapes = 车辆->m_车体刚体->getNbShapes();
		physx::PxShape* 子物体[64];
		车辆->m_车体刚体->getShapes(子物体, nbShapes);
		for (uint32 i = 0; i < 车辆->m_车体形状.size(); ++i) {
			车辆->m_车体形状[i]->userData = 车体[i];
			//车辆->m_车体刚体->userData = 车体[i];
		}
		for (uint32 i = 0; i < 车辆->m_车轮形状.size(); ++i) {
			车辆->m_车轮形状[i]->userData = 车轮[i];
		}
	}
}*/



/*void f_创建车(S_物理解算器* 解算器, 
				S_物体* 车体, 
				const S_车体参数& 车体参数, 
				vector<S_物体*> 车轮, 
				const vector<S_车轮参数>& 车轮参数, 
				const S_三角Mesh& 车体mesh
				//const vector<S_三角Mesh>& 车轮meshs
) {
	S_PhysX* px = dynamic_cast<S_PhysX*>(解算器->m_PhysX);
	//px->f_add车辆(车体, 车体参数, 车轮, 车轮参数);

	auto& PxCore = px->m_Core;


	uint32 车轮数 = 车轮参数.size();

	S_Px车* px车 = new S_Px车(PxCore.m_Physics, PxCore.m_Cooking, 车体参数, 车轮数);

	px车->m_车体刚体->userData = 车体;

	px车->f_add构建车体(PxCore.m_Physics, PxCore.m_Cooking, 车体mesh);

	for (uint32 i = 0; i < 车轮数; ++i) {
		S_Px车轮* px车轮 = new S_Px车轮(PxCore.m_Physics, PxCore.m_Cooking, 车轮参数[i]);
		//vec3 轮胎局部位置 = c车体->f_get位置();
		px车->f_add构建车轮(px车轮);
		px车轮->m_车轮形状->userData = 车轮[i];
	}

	//m_Px场景s[0]->addActor(*px车->m_车体刚体);

}*/


void f_Phy_set肌腱力度(S_Physics* phy, float32* value, int32 num) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco:

		break;
	}
}

void f_Phy_应用力(S_Physics* phy, const S_物理互交参数& 互交) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_Mujoco:
		f_PhyMujoco_应用力(static_cast<S_PhysicsMujoco*>(phy), 互交);
		break;
	}
}

S_物理体* f_create流体粒子(S_物理解算器* 解算器, S_物理材质& mat, const S_Tranform& t, uint32 num, E_物理引擎 物理引擎) {
	S_物理体* body = 0;

	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			body = f_PhysPBF_创建物理流体(解算器->m_PBF, mat, t, num);
		break;
	case E_物理引擎_ODE:
		//return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		//return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		//return f_FleX流体(解算器->m_FleX, geom, mat, t, num);
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
	return body;
}

S_物理体* f_Phy_create流体(S_Physics* 解算器, S_物理几何体& geom, S_物理材质& mat, const S_Tranform& t, E_物理引擎 物理引擎) {
	S_物理体* body = 0;

	switch (物理引擎) {
	case E_物理引擎::E_物理引擎_FLIP:
		body = f_FLIP创建流体(解算器, geom, mat, t);
		break;
	case E_物理引擎::E_物理引擎_PBF:
		
		break;
	case E_物理引擎_ODE:
		//return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		//return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		//return f_FleX流体(解算器->m_FleX, geom, mat, t, num);
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
	return body;
}

bool f_Phy_切换物理体类型(E_物理引擎 IdType, S_物理体* body, E_物理体类型 类型) {
	body->m_物理引擎枚举 = IdType;

	if (类型 == body->m_Type) {
		return false;
	}

	//phy->f_移除物理体(body, 0);
	switch (IdType) {
	case E_物理引擎::E_物理引擎_FLIP:
		f_FLIP_切换物理体类型(body, 类型);
		break;

	case E_物理引擎::E_物理引擎_FleX:
	case E_物理引擎::E_物理引擎_PBF:
		f_PhysPBF_切换物理体类型(body, 类型);
		break;
	case E_物理引擎_ODE:
		//return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		//return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
	
	return false;
}

void f_Phy_重置发射源(S_物理体* body)
{
	switch (body->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_PBF:
	case E_物理引擎::E_物理引擎_FleX:
		return f_PBF_重置发射体(body);
	case E_物理引擎::E_物理引擎_FLIP:
		break;
	case E_物理引擎_ODE:
		break;
	case E_物理引擎_NewTon:
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
}

S_体素* f_Phy_get发射源体素(S_物理体* body) {
	switch (body->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_PBF:
	case E_物理引擎::E_物理引擎_FleX:
		return f_PhysPBF_get物体体素(body);
		break;
	case E_物理引擎::E_物理引擎_FLIP:
		return f_FLIP_get物体体素(body);
		break;
	
	case E_物理引擎_ODE:
		//return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		//return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}

	return nullptr;
}

S_域区* f_Phy_get域属性(S_Physics* phy) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_FLIP:
		return f_FLIP_get域属性(phy);
	case E_物理引擎::E_物理引擎_PBF:
		return phy->f_get域属性();
	case E_物理引擎_ODE:
		//return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		//return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		//return f_FleX流体(解算器->m_FleX, geom, mat, t, num);
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
	return nullptr;
}

uint64 f_Phy_get粒子数量(S_Physics* phy) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_FLIP:
		break;
	case E_物理引擎::E_物理引擎_PBF:
		return f_PBF_get粒子总数(phy);
	case E_物理引擎_ODE:
		//return f_ODE刚体(解算器->m_ODE, geom, mat);
		break;
	case E_物理引擎_NewTon:
		//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		//return f_Chrono刚体(geom, mat);
		break;
	case E_物理引擎_FleX:
		//return f_FleX流体(解算器->m_FleX, geom, mat, t, num);
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}

	return uint64();
}

float32 f_Phy_get粒子大小(S_Physics* phy) {
	switch (phy->m_IdType)
	{
	case E_物理引擎::E_物理引擎_PBF:
		return f_PBF_get粒子大小(phy);
	case E_物理引擎_FleX:
		
		break;
	case E_物理引擎_ODE:
		
		break;
	case E_物理引擎_NewTon:
		
		break;
	case E_物理引擎_Bullet:
		
		break;
	case E_物理引擎_Chrono:
		
		break;

	case E_物理引擎_PhysX:
	
		break;
	default:
		break;
	}

	return 1.0f;
}







void f_Phy_get域中粒子(S_Physics* phy, const vec3& coord, std::vector<vec3>& particle) {
	switch (phy->m_IdType)
	{
	case E_物理引擎::E_物理引擎_PBF:
		f_PBF_get域中粒子(phy, coord, particle);
		break;
	case E_物理引擎::E_物理引擎_FleX:

		break;
	case E_物理引擎::E_物理引擎_ODE:

		break;
	case E_物理引擎::E_物理引擎_NewTon:

		break;
	case E_物理引擎::E_物理引擎_Bullet:

		break;
	case E_物理引擎::E_物理引擎_Chrono:

		break;

	case E_物理引擎::E_物理引擎_PhysX:

		break;
	default:
		break;
	}
}

uvec2 f_Phy_get粒子区间(S_物理体* body)
{
	switch (body->m_物理引擎枚举)
	{
	case E_物理引擎::E_物理引擎_FleX:
	case E_物理引擎::E_物理引擎_PBF:
		return f_PBF_get物理体粒子区间(body);
		break;
	case E_物理引擎_ODE:
		break;
	case E_物理引擎_NewTon:
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
	return uvec2();
}

uvec4 f_Phy_get粒子发射区间(S_物理体* body, float32 速率)
{
	switch (body->m_物理引擎枚举)
	{
	case E_物理引擎::E_物理引擎_FleX:
	case E_物理引擎::E_物理引擎_PBF:
		return f_PBF_get粒子发射区间(body, 速率);
		break;
	case E_物理引擎_ODE:
		break;
	case E_物理引擎_NewTon:
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
	return uvec4();
}

uint64 f_Phy_get发射总数(S_物理体* body)
{
	switch (body->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_FleX:
	case E_物理引擎::E_物理引擎_PBF:
		return f_PBF_get发射总数(body);
		break;

	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
	return uint64();
}









void f_物理体添加到引擎(S_物理解算器* 解算器, S_物理体* body, uint32 sceneKey, E_物理引擎 物理引擎) {
	switch (body->m_物理引擎枚举)
	{
	case E_物理引擎_FleX:
		解算器->m_FleX->f_添加物理体(body, sceneKey);
		break;
	case E_物理引擎_ODE:
		解算器->m_ODE->f_添加物理体(body, sceneKey);
		break;
	case E_物理引擎_NewTon:
		解算器->m_NewTon->f_添加物理体(body, sceneKey);
		break;
	case E_物理引擎_Bullet:
		解算器->m_Bullet->f_添加物理体(body, sceneKey);
		return;
	case E_物理引擎_Chrono:
		解算器->m_Chrono->f_添加物理体(body, sceneKey);
		return ;
	
	case E_物理引擎_PhysX: 
		解算器->m_PhysX->f_添加物理体(body, sceneKey);
		break;
	default:
		break;
	}
}

void f_物理体从引擎移除(S_物理解算器* 解算器, S_物理体* body, uint32 sceneKey, E_物理引擎 物理引擎) {
	switch (body->m_物理引擎枚举) {
	case E_物理引擎_ODE:
		解算器->m_ODE->f_移除物理体(body, sceneKey);
		break;
	case E_物理引擎_Bullet:
		{
			//S_PhysicsBullet* bt = dynamic_cast<S_PhysicsBullet*>(解算器->m_Bullet);
			解算器->m_Bullet->f_移除物理体(body, sceneKey);
		}
		
		return;
	case E_物理引擎_Chrono:
		解算器->m_Chrono->f_移除物理体(body, sceneKey);
		return;
	case E_物理引擎_FleX:
		解算器->m_FleX->f_移除物理体(body, sceneKey);
		break;
	case E_物理引擎_PhysX:
		解算器->m_PhysX->f_移除物理体(body, sceneKey);
		break;
	default:
		break;
	}
	
}

bool f_Phy_物理体添加到引擎(S_Physics* phy, S_物理体* body) {
	switch (phy->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			return f_PBF_添加物体(phy, body);
		} break;

		case E_物理引擎::E_物理引擎_PhysX: {

		} break;
	}

	return false;
}

void f_Phy_add静态碰撞网格(S_Physics* phy, std::vector<vec3>& vert, std::vector<uvec3>& index) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		return f_PhysPBF_add静态碰撞网格(phy, vert, index);
	} break;

	case E_物理引擎::E_物理引擎_PhysX: {

	} break;
	}
}


void f_物理体添加碰撞回调(S_物理解算器* 解算器, S_物理体* body, uint32 sceneKey, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_Bullet:
		解算器->m_Bullet->f_添加物理体(body, sceneKey);
		return;
	case E_物理引擎_Chrono:
		解算器->m_Chrono->f_添加物理体(body, sceneKey);
		return;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		解算器->m_PhysX->f_添加物理体(body, sceneKey);
		break;
	default:
		break;
	}
}

车辆容器_t f_get车辆(S_物理解算器* 解算器, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_Bullet:
		return f_getBullet车辆(解算器->m_Bullet);
	case E_物理引擎_Chrono:
		break;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
	return 车辆容器_t();
}

void f_施加力(S_物理解算器* 解算器, S_物理体* body, const vec3& 力, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PhysPBF_施加单方向外力(解算器->m_PBF, body, 力);
		case E_物理引擎_ODE:
			break;
		case E_物理引擎_NewTon:
			break;
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_Chrono:
			break;
		case E_物理引擎_FleX:
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	};
}

void f_Phy_设置粒子数量(S_物理解算器* 解算器, S_物理体* body, uint32 num, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			f_PhysPBF_设置流体粒子数量(解算器->m_PBF, body, num);
			break;
		case E_物理引擎_ODE:
			//return f_ODE刚体(解算器->m_ODE, geom, mat);
			break;
		case E_物理引擎_NewTon:
			//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
			break;
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_Chrono:
			//return f_Chrono刚体(geom, mat);
			break;
		case E_物理引擎_FleX:
			//return f_FleX流体(解算器->m_FleX, geom, mat, t, num);
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}
}

void f_Phy_拷贝粒子坐标(S_物理解算器* 解算器, S_物理体* body, vec3* c, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			f_PhysPBF_取粒子坐标(解算器->m_PBF, body, c);
			break;
		case E_物理引擎_ODE:
			//return f_ODE刚体(解算器->m_ODE, geom, mat);
			break;
		case E_物理引擎_NewTon:
			//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
			break;
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_Chrono:
			//return f_Chrono刚体(geom, mat);
			break;
		case E_物理引擎_FleX:
			//return f_FleX流体(解算器->m_FleX, geom, mat, t, num);
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}

	
}

void f_Phy_拷贝粒子速度(S_物理解算器* 解算器, S_物理体* body, vec3* c, E_物理引擎 物理引擎) {
}








vec3* f_Phy_映射粒子坐标(S_物理解算器* 解算器, S_物理体* body, E_物理引擎 物理引擎) {
	vec3* p = 0;
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PhysPBF_映射流体粒子坐标(解算器->m_PBF, body);
		case E_物理引擎_ODE:
			//return f_ODE刚体(解算器->m_ODE, geom, mat);
			break;
		case E_物理引擎_NewTon:
			//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
			break;
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_Chrono:
			//return f_Chrono刚体(geom, mat);
			break;
		case E_物理引擎_FleX:
			//return f_FleX流体(解算器->m_FleX, geom, mat, t, num);
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}

	return nullptr;
}

vec3* f_Phy_映射粒子速度(S_物理解算器* 解算器, S_物理体* body, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PhysPBF_映射流体粒子速度(解算器->m_PBF, body);
		case E_物理引擎_ODE:
			//return f_ODE刚体(解算器->m_ODE, geom, mat);
			break;
		case E_物理引擎_NewTon:
			//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
			break;
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_Chrono:
			//return f_Chrono刚体(geom, mat);
			break;
		case E_物理引擎_FleX:
			//return f_FleX流体(解算器->m_FleX, geom, mat, t, num);
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}

	return nullptr;
}

vec3* f_Phy_映射粒子外力(S_物理解算器* 解算器, S_物理体* body, E_物理引擎 物理引擎) {
	switch (物理引擎) {
		case E_物理引擎::E_物理引擎_PBF:
			return f_PhysPBF_映射流体粒子外力(解算器->m_PBF, body);
		case E_物理引擎_ODE:
			//return f_ODE刚体(解算器->m_ODE, geom, mat);
			break;
		case E_物理引擎_NewTon:
			//if (解算器->m_NewTon) return f_NewTon刚体(解算器->m_NewTon, geom, mat);
			break;
		case E_物理引擎_Bullet:
			break;
		case E_物理引擎_Chrono:
			//return f_Chrono刚体(geom, mat);
			break;
		case E_物理引擎_FleX:
			//return f_FleX流体(解算器->m_FleX, geom, mat, t, num);
			break;
		case E_物理引擎_PhysX:
			break;
		default:
			break;
	}

	return nullptr;
}







void f_Phy_set解算器域分辨率(S_Physics* phy, E_物理引擎 type, uint32 分辨率, vec3 世界大小, float32 单元间隔) {
	switch (type) {
	case E_物理引擎::E_物理引擎_FLIP: {
		S_域区* vo = f_FLIP_get域属性(phy);

		vo->m_单元属性.m_分辨率 = { 分辨率 ,分辨率 ,分辨率 };

		if(vo->m_Mask) free(vo->m_Mask);
		vo->m_Mask = (uint8*)calloc(vo->m_单元属性.m_分辨率.x * vo->m_单元属性.m_分辨率.y * vo->m_单元属性.m_分辨率.z, sizeof(uint8));

		f_FLIP_set解算器域分辨率(phy, 0);

		break;
	}
		
	}
}

void f_Phy_set解算器域分辨率(S_Physics* phy, float32 分辨率) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PBF_set粒子半径(phy, 分辨率);
	} break;


	case E_物理引擎::E_物理引擎_FLIP: {
		
	} break;

	}
}

void f_Phy_set解算器域(S_Physics* phy, const vec3& 域大小, const vec3& 域偏移, float32 单元大小) {
	switch (phy->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PBF_set域(phy, 域大小, 域偏移, 单元大小);
	} break;


	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
}


void f_Phy_set流体速度(S_Physics* 解算器, S_Object* body) {
	S_域区* vo = f_FLIP_get域属性(解算器);

	S_物体* obj = dynamic_cast<S_物体*>(body);

	//f_fromMesh创建体素(vo, f_ob_from物体Mesh(obj), { 0,0,0 }, { 0,0,0,1 }, { 1,1,1 }, 0.1);

}


void f_Phy_set粒子发射(S_物理体* e, std::vector<S_VN>& vn) {
	switch (e->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_PBF: {
		S_体素* volex = f_Phy_get发射源体素(e);

		uint32 num = vn.size();
		volex->m_坐标.resize(num);
		volex->m_法线.resize(num);
		for (uint32 i = 0; i < num; ++i) {
			volex->m_坐标[i] = vn[i].vert;
			volex->m_法线[i].x = vn[i].normal.x;
			volex->m_法线[i].y = vn[i].normal.y;
			volex->m_法线[i].z = vn[i].normal.z;
		}


		//f_PhysPBF_set粒子发射数量(e, vn.size());
	} break;

	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
}

void f_Phy_set粒子发射最大数量(S_物理体* e, uint64 num) {
	switch (e->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_FleX:
	case E_物理引擎::E_物理引擎_PBF: {
		f_PhysPBF_set粒子发射数量(e, num);
	} break;

	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
}

void f_Phy_set流体飞溅粒子数量(S_Physics* 解算器, uint32 num)
{
	switch (解算器->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PhysPBF_set飞溅粒子数量(解算器, num);
	} break;

	case E_物理引擎::E_物理引擎_FLIP: {

	} break;

	}
}

void f_Phy_set粒子区间(S_物理体* body, const uvec2& 区间, uint64 全局偏移)
{
	body->m_全局偏移 = 全局偏移;

	switch (body->m_物理引擎枚举) {
	case E_物理引擎::E_物理引擎_FleX:
	case E_物理引擎::E_物理引擎_PBF:
		return f_PBF_set流体粒子区间(body, 区间);
		break;
	case E_物理引擎_ODE:
		break;
	case E_物理引擎_NewTon:
		break;
	case E_物理引擎_Bullet:
		break;
	case E_物理引擎_Chrono:
		break;
	case E_物理引擎_PhysX:
		break;
	default:
		break;
	}
}

void f_Phy_添加物理体(S_Physics* 解算器, std::vector<S_物理体*>& body) {

	switch (解算器->m_IdType) {
	case E_物理引擎::E_物理引擎_Bullet: {
		f_Bullet_添加物理体(解算器, body);
		break;
	}

	case E_物理引擎::E_物理引擎_Mujoco: {
		f_PhyMujoco_添加物理体(static_cast<S_PhysicsMujoco*>(解算器), body);
		break;
	}
		case E_物理引擎::E_物理引擎_PBF: {
			for (auto ob : body) {
				if (ob->m_Data) {
					S_物体* obj = dynamic_cast<S_物体*>(ob->m_绑定物体);
					f_PBF_添加物体(解算器, ob);

				}
				//S_体素* v = f_Phy_get发射源体素(ob);
				//f_fromMesh创建体素(*vo, f_ob_from物体Mesh(obj), { 0,0,0 }, { 1,0,0,0 }, { 1,1,1 }, 0.1);
				//uint32 发射源层 = v->m_维度.x * v->m_维度.y;
				//uint32 层 = vo->m_分辨率.x * vo->m_分辨率.y;
				/*Concurrency::parallel_for<uint32>(0, v->m_维度.z, [&](uint32 z) {
					for (uint32 y = 0; y < v->m_维度.y; ++y) {
						for (uint32 x = 0; x < v->m_维度.x; ++x) {

						}
					}
				});*/
			}
			//f_FLIP发射流体(解算器, body);
			break;
		}

		case E_物理引擎::E_物理引擎_FLIP: {
			S_域区* vo = f_FLIP_get域属性(解算器);
		

			for (auto ob : body) {
				S_物体* obj = dynamic_cast<S_物体*>(ob->m_绑定物体);

				S_体素* v = f_Phy_get发射源体素(ob);

				uint32 发射源层 = v->m_维度.x * v->m_维度.y;
				uint32 层 = vo->m_单元属性.m_分辨率.x * vo->m_单元属性.m_分辨率.y;



				Concurrency::parallel_for<uint32>(0, v->m_维度.z, [&](uint32 z) {
					for (uint32 y = 0; y < v->m_维度.y; ++y) {
						for (uint32 x = 0; x < v->m_维度.x; ++x) {
							vec3 offset = (obj->m_变换.location - vo->m_单元属性.m_域世界偏移) / vo->m_单元属性.m_单元大小;
							ivec3 gOffset = { offset.x, offset.y, offset.z };
							gOffset.x += x;
							gOffset.y += y;
							gOffset.z += z;
							//uvec3 gOffset = vec_Max({ offset.x, offset.y, offset.z }, uvec3{0,0,0});

							if (gOffset.x < 0 || gOffset.x >= vo->m_单元属性.m_分辨率.x) break;
							if (gOffset.y < 0 || gOffset.y >= vo->m_单元属性.m_分辨率.y) break;
							if (gOffset.z < 0 || gOffset.z >= vo->m_单元属性.m_分辨率.z) break;

							uint64 发射源ID = 发射源层 * z + v->m_维度.x * y + x;
							uint64 ID = 层 * gOffset.z + vo->m_单元属性.m_分辨率.x * gOffset.y + gOffset.x;

							if (v->m_Mask[发射源ID]) {
								vo->m_Mask[ID] = 1;
							}

						}
					}
					});

			}

			f_FLIP发射流体(解算器, body);

			break;
		}
		
	}

}

void f_Phy_取流体调试数据(S_Physics* 解算器, void* data) {
	switch (解算器->m_IdType) {
		case E_物理引擎::E_物理引擎_PBF: {
			f_PBF_流体数据写入到顶点缓存(解算器, (vec4*)data);
		} break;

		case E_物理引擎::E_物理引擎_FLIP: {
			f_FLIP流体数据写入到顶点缓存(解算器, (S_FLIP可视数据*)data);
		} break;
	}

	
}

void f_Phy_取体素调试数据(S_Physics* 解算器, std::vector<vec4>& data) {
	switch (解算器->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		f_PBF_体素数据写入到顶点缓存(解算器, data);
	} break;

	case E_物理引擎::E_物理引擎_FLIP: {
		//f_FLIP流体数据写入到顶点缓存(解算器, (S_FLIP可视数据*)data);
	} break;
	}
}

void f_Phy_get静态碰撞空间树调试数据(const S_Physics* 解算器, std::vector<vec4>& data, bool 不包含空单元) {
	switch (解算器->m_IdType) {
	case E_物理引擎::E_物理引擎_PBF: {
		if (不包含空单元) {
			f_PBF_静态碰撞单元树写入缓存(解算器, data);
		}
		else {
			f_PBF_静态碰撞空间树写入缓存(解算器, data);
		}
	} break;

	case E_物理引擎::E_物理引擎_FLIP: {
		//f_FLIP流体数据写入到顶点缓存(解算器, (S_FLIP可视数据*)data);
	} break;
	}
}




/*void f_取碰撞物体(S_物理解算器* 解算器, std::vector<S_物理体>& objs, uint32 scenekey, E_物理引擎 物理引擎) {
	switch (物理引擎) {
	case E_物理引擎_Bullet:
		解算器->m_Bullet->f_添加物理体(body, sceneKey);
		return;
	case E_物理引擎_Chrono:
		解算器->m_Chrono->f_添加物理体(body, sceneKey);
		return;
	case E_物理引擎_FleX:
		break;
	case E_物理引擎_PhysX:
	{
		S_PhysX* px = dynamic_cast<S_PhysX*>(解算器->m_PhysX);
		px->f_添加物理体(body, sceneKey);
	}
	break;
	default:
		break;
	}
}*/



